home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / slub_def.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  6.7 KB  |  250 lines
  1. #ifndef _LINUX_SLUB_DEF_H
  2. #define _LINUX_SLUB_DEF_H
  3.  
  4. /*
  5.  * SLUB : A Slab allocator without object queues.
  6.  *
  7.  * (C) 2007 SGI, Christoph Lameter
  8.  */
  9. #include <linux/types.h>
  10. #include <linux/gfp.h>
  11. #include <linux/workqueue.h>
  12. #include <linux/kobject.h>
  13.  
  14. enum stat_item {
  15.     ALLOC_FASTPATH,        /* Allocation from cpu slab */
  16.     ALLOC_SLOWPATH,        /* Allocation by getting a new cpu slab */
  17.     FREE_FASTPATH,        /* Free to cpu slub */
  18.     FREE_SLOWPATH,        /* Freeing not to cpu slab */
  19.     FREE_FROZEN,        /* Freeing to frozen slab */
  20.     FREE_ADD_PARTIAL,    /* Freeing moves slab to partial list */
  21.     FREE_REMOVE_PARTIAL,    /* Freeing removes last object */
  22.     ALLOC_FROM_PARTIAL,    /* Cpu slab acquired from partial list */
  23.     ALLOC_SLAB,        /* Cpu slab acquired from page allocator */
  24.     ALLOC_REFILL,        /* Refill cpu slab from slab freelist */
  25.     FREE_SLAB,        /* Slab freed to the page allocator */
  26.     CPUSLAB_FLUSH,        /* Abandoning of the cpu slab */
  27.     DEACTIVATE_FULL,    /* Cpu slab was full when deactivated */
  28.     DEACTIVATE_EMPTY,    /* Cpu slab was empty when deactivated */
  29.     DEACTIVATE_TO_HEAD,    /* Cpu slab was moved to the head of partials */
  30.     DEACTIVATE_TO_TAIL,    /* Cpu slab was moved to the tail of partials */
  31.     DEACTIVATE_REMOTE_FREES,/* Slab contained remotely freed objects */
  32.     ORDER_FALLBACK,        /* Number of times fallback was necessary */
  33.     NR_SLUB_STAT_ITEMS };
  34.  
  35. struct kmem_cache_cpu {
  36.     void **freelist;    /* Pointer to first free per cpu object */
  37.     struct page *page;    /* The slab from which we are allocating */
  38.     int node;        /* The node of the page (or -1 for debug) */
  39.     unsigned int offset;    /* Freepointer offset (in word units) */
  40.     unsigned int objsize;    /* Size of an object (from kmem_cache) */
  41. #ifdef CONFIG_SLUB_STATS
  42.     unsigned stat[NR_SLUB_STAT_ITEMS];
  43. #endif
  44. };
  45.  
  46. struct kmem_cache_node {
  47.     spinlock_t list_lock;    /* Protect partial list and nr_partial */
  48.     unsigned long nr_partial;
  49.     unsigned long min_partial;
  50.     struct list_head partial;
  51. #ifdef CONFIG_SLUB_DEBUG
  52.     atomic_long_t nr_slabs;
  53.     atomic_long_t total_objects;
  54.     struct list_head full;
  55. #endif
  56. };
  57.  
  58. /*
  59.  * Word size structure that can be atomically updated or read and that
  60.  * contains both the order and the number of objects that a slab of the
  61.  * given order would contain.
  62.  */
  63. struct kmem_cache_order_objects {
  64.     unsigned long x;
  65. };
  66.  
  67. /*
  68.  * Slab cache management.
  69.  */
  70. struct kmem_cache {
  71.     /* Used for retriving partial slabs etc */
  72.     unsigned long flags;
  73.     int size;        /* The size of an object including meta data */
  74.     int objsize;        /* The size of an object without meta data */
  75.     int offset;        /* Free pointer offset. */
  76.     struct kmem_cache_order_objects oo;
  77.  
  78.     /*
  79.      * Avoid an extra cache line for UP, SMP and for the node local to
  80.      * struct kmem_cache.
  81.      */
  82.     struct kmem_cache_node local_node;
  83.  
  84.     /* Allocation and freeing of slabs */
  85.     struct kmem_cache_order_objects max;
  86.     struct kmem_cache_order_objects min;
  87.     gfp_t allocflags;    /* gfp flags to use on each alloc */
  88.     int refcount;        /* Refcount for slab cache destroy */
  89.     void (*ctor)(void *);
  90.     int inuse;        /* Offset to metadata */
  91.     int align;        /* Alignment */
  92.     const char *name;    /* Name (only for display!) */
  93.     struct list_head list;    /* List of slab caches */
  94. #ifdef CONFIG_SLUB_DEBUG
  95.     struct kobject kobj;    /* For sysfs */
  96. #endif
  97.  
  98. #ifdef CONFIG_NUMA
  99.     /*
  100.      * Defragmentation by allocating from a remote node.
  101.      */
  102.     int remote_node_defrag_ratio;
  103.     struct kmem_cache_node *node[MAX_NUMNODES];
  104. #endif
  105. #ifdef CONFIG_SMP
  106.     struct kmem_cache_cpu *cpu_slab[NR_CPUS];
  107. #else
  108.     struct kmem_cache_cpu cpu_slab;
  109. #endif
  110. };
  111.  
  112. /*
  113.  * Kmalloc subsystem.
  114.  */
  115. #if defined(ARCH_KMALLOC_MINALIGN) && ARCH_KMALLOC_MINALIGN > 8
  116. #define KMALLOC_MIN_SIZE ARCH_KMALLOC_MINALIGN
  117. #else
  118. #define KMALLOC_MIN_SIZE 8
  119. #endif
  120.  
  121. #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
  122.  
  123. /*
  124.  * We keep the general caches in an array of slab caches that are used for
  125.  * 2^x bytes of allocations.
  126.  */
  127. extern struct kmem_cache kmalloc_caches[PAGE_SHIFT + 1];
  128.  
  129. /*
  130.  * Sorry that the following has to be that ugly but some versions of GCC
  131.  * have trouble with constant propagation and loops.
  132.  */
  133. static __always_inline int kmalloc_index(size_t size)
  134. {
  135.     if (!size)
  136.         return 0;
  137.  
  138.     if (size <= KMALLOC_MIN_SIZE)
  139.         return KMALLOC_SHIFT_LOW;
  140.  
  141. #if KMALLOC_MIN_SIZE <= 64
  142.     if (size > 64 && size <= 96)
  143.         return 1;
  144.     if (size > 128 && size <= 192)
  145.         return 2;
  146. #endif
  147.     if (size <=          8) return 3;
  148.     if (size <=         16) return 4;
  149.     if (size <=         32) return 5;
  150.     if (size <=         64) return 6;
  151.     if (size <=        128) return 7;
  152.     if (size <=        256) return 8;
  153.     if (size <=        512) return 9;
  154.     if (size <=       1024) return 10;
  155.     if (size <=   2 * 1024) return 11;
  156.     if (size <=   4 * 1024) return 12;
  157. /*
  158.  * The following is only needed to support architectures with a larger page
  159.  * size than 4k.
  160.  */
  161.     if (size <=   8 * 1024) return 13;
  162.     if (size <=  16 * 1024) return 14;
  163.     if (size <=  32 * 1024) return 15;
  164.     if (size <=  64 * 1024) return 16;
  165.     if (size <= 128 * 1024) return 17;
  166.     if (size <= 256 * 1024) return 18;
  167.     if (size <= 512 * 1024) return 19;
  168.     if (size <= 1024 * 1024) return 20;
  169.     if (size <=  2 * 1024 * 1024) return 21;
  170.     return -1;
  171.  
  172. /*
  173.  * What we really wanted to do and cannot do because of compiler issues is:
  174.  *    int i;
  175.  *    for (i = KMALLOC_SHIFT_LOW; i <= KMALLOC_SHIFT_HIGH; i++)
  176.  *        if (size <= (1 << i))
  177.  *            return i;
  178.  */
  179. }
  180.  
  181. /*
  182.  * Find the slab cache for a given combination of allocation flags and size.
  183.  *
  184.  * This ought to end up with a global pointer to the right cache
  185.  * in kmalloc_caches.
  186.  */
  187. static __always_inline struct kmem_cache *kmalloc_slab(size_t size)
  188. {
  189.     int index = kmalloc_index(size);
  190.  
  191.     if (index == 0)
  192.         return NULL;
  193.  
  194.     return &kmalloc_caches[index];
  195. }
  196.  
  197. #ifdef CONFIG_ZONE_DMA
  198. #define SLUB_DMA __GFP_DMA
  199. #else
  200. /* Disable DMA functionality */
  201. #define SLUB_DMA (__force gfp_t)0
  202. #endif
  203.  
  204. void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
  205. void *__kmalloc(size_t size, gfp_t flags);
  206.  
  207. static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
  208. {
  209.     return (void *)__get_free_pages(flags | __GFP_COMP, get_order(size));
  210. }
  211.  
  212. static __always_inline void *kmalloc(size_t size, gfp_t flags)
  213. {
  214.     if (__builtin_constant_p(size)) {
  215.         if (size > PAGE_SIZE)
  216.             return kmalloc_large(size, flags);
  217.  
  218.         if (!(flags & SLUB_DMA)) {
  219.             struct kmem_cache *s = kmalloc_slab(size);
  220.  
  221.             if (!s)
  222.                 return ZERO_SIZE_PTR;
  223.  
  224.             return kmem_cache_alloc(s, flags);
  225.         }
  226.     }
  227.     return __kmalloc(size, flags);
  228. }
  229.  
  230. #ifdef CONFIG_NUMA
  231. void *__kmalloc_node(size_t size, gfp_t flags, int node);
  232. void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
  233.  
  234. static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
  235. {
  236.     if (__builtin_constant_p(size) &&
  237.         size <= PAGE_SIZE && !(flags & SLUB_DMA)) {
  238.             struct kmem_cache *s = kmalloc_slab(size);
  239.  
  240.         if (!s)
  241.             return ZERO_SIZE_PTR;
  242.  
  243.         return kmem_cache_alloc_node(s, flags, node);
  244.     }
  245.     return __kmalloc_node(size, flags, node);
  246. }
  247. #endif
  248.  
  249. #endif /* _LINUX_SLUB_DEF_H */
  250.